DR. AJAY KUMAR PATHAK
ASSISTANT PROFESSOR
READ ALL THE NOTES CHAPTER WISE
MINOR PAPER
SUBJECT NAME:- MN–2C (Th):- SOFTWARE TESTING
FOR B. Sc. IT.
SEM 6 F.Y.U.G.P.
Copyright © by Dr. Ajay kumar pathak
B. Sc. IT. SEMESTER 6 NOTES BASED ON NEP
SUBJECT : MN–2C (Th): SOFTWARE TESTING
(To be selected by the students from)
UNIT 1 (UNIT NAME):- INTRODUCTION TO SOFTWARE TESTING
Semester Examination and Distribution of Marks
Semester internal examination (SIE):- 25 Marks
End Semester Examination (ESE) :- 75 Marks
Objective: The objective of this course is to provide students with an understanding of software testing principles, techniques, and methodologies. The course aims to develop students' skills in designing test cases, executing tests, and reporting defects.
Course Outcome: By the end of this course, students should be able to:
·
Understand the
importance of software testing in the software development life cycle.
·
Apply different
testing techniques and methodologies.
·
Design and
execute test cases to verify software functionality.
·
Identify and
report software defects effectively.
·
Understand the
role of automated testing tools in software testing.
-: NOTES READ FROM HERE :-
UNIT- 1 :- INTRODUCTION TO SOFTWARE TESTING
SOFTWARE:-
A software is a fundamental
term in the computer world that refers to a program or set of programs designed
to perform specific tasks on a computer. In simple terms, software encompasses
the programs, rules, and instructions that allow a computer to perform various functions.
When we talk about software, we refer to something intangible that is in our
computers, such as Microsoft Word, the operating system calculator or the
digital calendar that we use to schedule meetings.
The software works using a
programming language known as Binary code, represented by zeros and ones. This
code allows programmers to instruct the computer what actions to perform, how
and when to execute them.
Who Develops
Software?:-
Software developers, also
called programmers or coders, are the architects and builders of software. They
write code in various programming languages like Python, Java, C++, or
JavaScript. It creates software that solves real-world problems or adds value
to users.
INTRODUCTION TO
SOFTWARE TESTING:-
Software testing is an integral
part of the software development process designed to ensure that every product
feature is dependable and high-quality. Teams that conduct software testing do
it in such a way that it provides comprehensive info about errors in the
architecture, sees that it meets the stated product requirements, and performs
as intended. This article will consider the concepts and terminologies commonly
associated with software testing.
Testing software is crucial in
the software development process. It ensures that the software meets quality
standards, functions correctly and remains secure before it is released to
users. Testing plays a role in the development cycle by detecting issues, which
helps in resolving them efficiently, saving time and money while improving the
products’ dependability.
What is the purpose
of Software testing?:-
Software testing is done by the
developers / product teams to detect and rectify errors or faults early in the
software development process. The early detection significantly minimises the
risks of issues arising in the finished product. Defects arise in software due
to many reasons. As a matter of fact it is said that every software application
has some defects embedded in it but not every defect is a threat to the system.
There is a lot that can be accomplished with the help of software testing.
Testing helps in evaluating the quality of software.
There are many reasons why
software testing has gained so much of importance in the field of information
technology. Firstly, testing helps in reducing the overall cost of the software
development project. If testing is ignored in the initial development stages to
save a small amount of money then it may turn out to be a very expensive matter
later because as you move on with development process it becomes more and more
difficult to trace back defects and rectifying one defect somewhere can
introduce another defect in some other module.
The requirement is finalized
after several discussions with the client. Testing ensures that the software
behaves and looks exactly like what is mentioned in the requirements
specification document, so that when software is delivered to the client there
are no arguments about the variation from the original requirements. Software
testing helps in strengthening the market reputation of a company. Well tested
software is of good quality and good quality means better feedback and reviews.
In order to achieve best
results it is important to organize all your testing efforts and this is what
this Software Testing Training provided by International Software Test
Institute is all about. Software testing cannot be fruitful without proper
planning. To live up to the expectations of the client it is important to plan
every step carefully. A lot of things need to be considered in order plan your
testing efforts. Software testing should be planned keeping budget, schedule
and performance in mind in order to achieve best results.
All testing activities require
planning. It is important to outline a test plan that will give in details
about how each activity will be carried out. Test plan is also required to
ensure that all aspects of the software are covered thoroughly and there is no
repetition of testing process so that time and effort is not wasted.
The latest trend now is to involve the testing team in specification writing process. It is important that the testing team understands the requirements of the client clearly as the entire development is based on the requirement defined by the client. Anything that is not in line with the requirement is a defect. So, the testing team should have a clear idea about what the final outcome of running software should be like. As a matter of fact it is important to start writing test cases in parallel to specification writing. This will help the testers analyze whether all the requirements are testable or not.
FUNDAMENTALS OF
SOFTWARE TESTING :-
Fundamentals of Software
Testing refer to the basic concepts, principles, objectives, processes, and
techniques that are used to ensure that a software system works correctly and
meets the specified requirements. Software testing is a systematic process of
evaluating a software application to identify differences between expected and
actual results and to detect defects, errors, or missing requirements. It is an
essential part of the Software
Development Life Cycle (SDLC) because without proper testing, software
may fail after deployment, leading to financial loss, security risks, or damage
to reputation.
Software testing is not just
about finding bugs; it is about ensuring quality. Quality means the software
should be reliable, efficient, secure, easy to use, and maintainable. When a
developer writes a program, there is always a possibility of mistakes. These
mistakes are called errors. When an error exists in code, it becomes a defect
(bug). When the defect affects the system during execution, it results in a
failure. Testing helps in identifying these defects before the software reaches
the user.
TYPES OF SOFTWARE
TESTING:-
There are different types of
software testing, each serving a unique process for quality assurance.
(1) Functional Testing
(2) Non-Functional Testing
(1) Functional Testing:- Functional testing is the most common type of software
testing. During this testing, testers prepare various test cases to simulate
user interactions and evaluate the software’s functionality in response to
these interactions.
Functional testing focuses
on verifying the functionality of the software system. It is a type of testing
that is done to ensure that the system works as intended and meets the
functional requirements specified by the stakeholders. Functional testing is
concerned with what the software system does, and how it performs its
functions.
The Functional
Testing are:-
(1) Unit Testing or module testing:-
(2) Integration Testing
(3) System Testing
(4) Acceptance Testing
(1) UNIT TESTING OR MODULE TESTING:- Unit
testing is a software testing method that focuses on individual units or
modules of the software to determine whether they work correctly. A unit is the
smallest testable part of any software and usually has one or a few inputs and
a single output. In procedural programming, a unit may be an individual
procedure or function.
Unit testing is a fundamental
practice in software engineering and is the first level of software testing,
conducted before integration testing. The process involves writing code to test
the functionality and behavior of the software components and then running
those tests to ensure every aspect of the software behaves as expected.
Unit testing is a critical part
of the software development process. It helps to validate the quality of your
code.
Unit test example:- Here is an
example of a very basic method in Python and some test cases with corresponding
unit test code.
Python method
def add_two_numbers(x, y):
return x + y
NAMES OF POPULAR UNIT
TESTING TOOLS USED IN DIFFERENT PROGRAMMING LANGUAGES:-
(1) For Java:- JUnit, TestNG, Mockito
(2) For Python:- unittest, pytest, nose2
(3) For C and C++:- CppUnit, Google Test, Unity
(4) For .NET:- NUnit, xUnit.net, MSTest
(5) For JavaScript:- Jest, Mocha, Jasmine
(6) For PHP:-PHPUnit
Unit testing
strategies:-
(1) Logic checks:- Does the system perform the right calculations
and follow the right path through the code given a correct, expected input? Are
all paths through the code covered by the given inputs?
(2) Boundary checks:- For the given inputs, how does the system
respond? How does it respond to typical inputs, edge cases, or invalid inputs?
(3) Error handling:- When there are errors in inputs, how does the
system respond? Is the user prompted for another input? Does the software
crash?
(4) Object-oriented checks:- If the state of any persistent objects
is changed by running the code, is the object updated correctly?
Unit testing
advantages:-
(1) Early bug detection:- Unit testing allows developers to catch
and correct bugs at an early stage in the development process. As tests are run
on individual units, it becomes easier to identify the exact location of a
defect. This early bug detection not only saves time but also reduces the cost
associated with fixing bugs later in the development cycle.
(2) Improved code quality:- Unit testing significantly improves the
quality of the code. The process of writing tests forces developers to think
through their code and its expected behavior, leading to a better understanding
of the problem they’re trying to solve and consequently, better code.
Additionally, with tests in place, developers can refactor their code
confidently, knowing that they’ll quickly catch any introduced bugs.
(3) Easier refactoring:- Refactoring, or restructuring existing
code without changing its external behavior, is made easier with unit testing.
Tests provide a safety net that enables developers to confidently change the
structure of the code. If a refactor breaks something, the tests will catch it,
allowing the developer to fix the issue immediately.
(4) Better collaboration:- Unit tests serve as a form of
documentation, providing a clear understanding of the code’s functionality to
other developers. This clarity fosters better collaboration among team members,
as they can confidently work on or modify the code without fear of breaking
existing functionality.
Unit testing
challenges :-
(1) Initial overhead:- Writing good unit tests requires time and effort,
which may seem like a hurdle, especially when project deadlines are tight.
However, the investment in unit testing can save considerable time in the long
run by catching bugs early and facilitating easier code maintenance.
(2) Maintaining tests:- As software evolves, so must its tests. Maintaining
test cases can be a challenge, especially in large projects with many
developers. If tests are not updated when the code is changed, they may fail
and give false-negative results, or worse, they may pass and give
false-positive results. A culture of updating tests as part of the code change
process is crucial to overcome this challenge.
(2) INTEGRATION TESTING:- Integration
testing is a software-testing approach in which various application components
or modules are joined and tested to evaluate how well they work together.
Integration testing seeks to help ensure that these assembled parts can
communicate with each other and interact successfully.
Integration testing refers to
the process in which the interface of different applications, modules or
components of a software application are tested as a combined group.
Integration testing is the second level of the software testing process. And
takes place right after unit testing and just before system testing. Simply
put, integration testing shows the testing team how well disparate elements
work together.
Its primary goal is
to ensure:-
(1) Correct data flow
(2) Proper communication
(3) Expected system behavior when components are connected
NAMES OF POPULAR
INTEGRATION TESTING TOOLS USED IN DIFFERENT TECHNOLOGIES:-
(1) For Java:- TestNG, JUnit, Arquillian
(2) For API / Web Services Integration:- Postman, SoapUI, REST
Assured, Karate
(3) For JavaScript / Node.js:- Jest, Mocha, Cypress
(4) For .NET:- NUnit, xUnit.net
Types of Integration
Testing:-
(1) Big-Bang Integration Testing:- All modules are integrated after unit testing is
completed, and the entire system is tested at once. Big-Bang Integration
Testing combines all modules at once after individual module testing. This
method is straightforward but can be challenging for large systems due to the
complexity of isolating errors.
(2) Bottom-Up Integration Testing:- It starts with integrating and testing lower-level modules
before moving to higher-level modules. It often uses test drivers to simulate
higher-level modules.
(3) Top-Down Integration Testing:- Begins with high-level modules and progressively
integrates and tests lower-level modules. It typically requires the use of
stubs to simulate the functionality of lower-level modules.
(4) Mixed Integration Testing (Sandwich
Approach):- Mixed Integration Testing, or
the Sandwich Approach, combines top-down and bottom-up methods. It's
particularly useful for large projects with multiple layers.
(5) Incremental Integration Testing:- Incremental Integration Testing involves integrating and testing modules step by step rather than all at once. This approach helps in isolating and fixing errors more efficiently.
Advantages of
Integration Testing:-
(1) Ensures the correctness of the interface:- Integration
testing helps find issues at the interface level.
(2) Improves overall system quality:- When checks at the
interface levels are passed, the quality of the whole system is improved.
(3) Enhances CI process:- It is often part of Continuous
Integration. The overall quality of the CI process is improved with the
addition of integration testing.
(4) Prevents regression issues:- Incremental integration
testing helps avoid regression issues by finding bugs.
(5) Improves user experience (UX):- Sometimes, individual
components have good UX. However, when combined with other components, the user
experience can be confusing, unintuitive, and frustrating. Integration testing
ensures that the UX is smooth and clear for the user.
Challenges of
Integration Testing:-
(1) Complex components:- Systems often have many large and small
interdependent components, which makes it difficult to isolate and test
individual integrations.
(2) Data management:- In large systems, ensuring that data is
correctly passed between units and accurately reflects real-world scenarios is
challenging.
(3) Environment setup:- It can be difficult to set up an
environment that integrates all the units and imitators production.
(4) Scalability testing: Testing how integrated components perform
under varying loads and scalability conditions can be difficult.
(5) Defect debugging: When many smaller components come together, it can be difficult to pinpoint the exact reason for a code bug.
(3) SYSTEM TESTING:- System testing is a crucial phase in software testing
that evaluates the complete, integrated software application to ensure it meets
all specified requirements. It takes place after integration testing and
involves testing the entire system as a whole to confirm that all components
work together seamlessly. This testing phase verifies functional and
non-functional requirements, including performance, usability, and security.
The System testing of software
or hardware conducted on an entire, integrated system to assess the system's
compliance with its specified requirements. It carried out by testers. This
testing also examines both functional and nonfunctional requirements of the
testing. It is the process of testing an integrated system to verify that it
meets specified requirements. It is the level of software testing performed
before Acceptance Testing and after Integration Testing. It comes under Black
Box testing, i.e., only external working features of the software evaluated
during this testing. It doesn't require any internal knowledge of the coding, programming,
design, etc., and completely based on users-perspective.
System testing
process:-
Step 1: Test
Environment Setup:- The first step of the
system testing process is to create a testing environment that closely mimics
(copy) the actual production environment. In this step, you configure
everything, including hardware and software, to set the tone for accurate
results.
Step 2: Test Case
Creation :- Once the testing environment
is ready, you should then proceed to develop test cases (a test case is a detailed, documented set
of conditions, inputs, and step-by-step actions used to verify whether a
specific feature or part of a software application functions correctly
according to its requirements ).
These
are different scenarios under which the system will be tested and cover all
functionalities. For instance, suppose you are testing an e-commerce
application; the case test may be to check if the Add to Cart functionality
works smoothly. The test case will detail the steps to add an item to the cart,
the expected system behavior during this, and the result.
Step 3: Test Data
Generation:- Relevant test data is
created or selected alongside test cases. It covers real-world situations as
well as valid and invalid data to test the system in detail. Continuing with
the e-commerce application example, test data can include valid user accounts
and payment details. Invalid data you can feed into the system are wrong
payment details or non-existent product IDs.
Step 4: Test Case
Execution:- Now that the test cases and
testing data are in place, the final testing starts. Systematic tests are run
either manually or using different tools to check if the actual results match
the expected results or if there are any discrepancies. For instance, the tester
executes the test case for adding an item to the cart. They perform the steps
as outlined and observe the system response. If the desired item is added to
the cart successfully, the system passes the test.
Step 5: Defect
Reporting:- If, unfortunately, the system
fails to work as expected and there are issues, a defect report is created and
sent to the development team. In this, you have to pen down the nature of the
defect, at which stage it occurs, and how it impacts the final user experience.
Suppose the Add to Cart button of the e-commerce application didn’t work; the
defect report will include the Button that is Unresponsive as the main detail.
The development team then gets back to fixing all issues, and once everything
is sorted, they send the application again to the testing team.
Step 6: Regression
Testing Starts:- After issues are fixed,
you may conduct a regression testing (Regression testing thoroughly checks and
ensures that new enhancements and features don’t negatively impact the
software’s functionality and that it continues to operate without any errors ) strategy to ensure that the new changes or
fixes have not adversely affected other features. This will test not only the
Add to Cart button but also other options like View Cart or Remove from Cart
functions to ensure everything is up to the mark.
Types of System
testing :-
(1) Functional Testing:- Also known as
functional completeness testing. To ensure that the functionality of the
product working as per the requirements defined or as per the user’s needs,
within the capabilities of the system.
Functionality
testing is one of the most important things the quality assurance team performs
to check if the software meets the set quality standards. It’s a form of
black-box testing in which the tester doesn’t know the internal coding of the
system but just focuses on input and output. Depending on the results—success
or failure—they decide if the system is ready to be released to the end users.
(2) Performance Testing:- Performance testing is all about checking the
performance of a system in terms of stability, response, and scalability. The
testing team simulates various real-world situations and examines how the
software solution works when there’s huge traffic. If there are any gaps, they
then fix it before delivering the product to the end users.
(3) Security Testing:- Security testing is one of the most important testing
types in which the testing team assesses the different security areas of the
system. For instance, they conduct rigorous testing to reveal system
vulnerabilities (weakness) that may result in data loss. It also helps you
verify that only specific personnel can access the system’s security functions,
ensuring a good reputation among customers.
(4) Recovery Testing:- Software systems often experience crashes and gaps,
but their ability to bounce back from failure matters most. This is where
recovery testing comes in. It verifies that the system is capable of recovering
from failures quickly. It also involves running tests on the system’s backup
functionality to ensure data is not lost during crashes.
(5) Compatibility Testing:- The compatibility testing technique evaluates the
software or system’s compatibility issues with other systems and hardware
setups. Testers also check how the software performs on different browsers to
ensure smooth and consistent performance across all platforms.
(6) Regression Testing:- As technology advances, adding new features to
existing systems and software becomes mandatory. Regression testing thoroughly
checks and ensures that new enhancements and features don’t negatively impact
the software’s functionality and that it continues to operate without any
errors.
(7) Load Testing:- In this type of software testing, your team is
responsible for checking how the system performs under normal and high loads.
It’s usually implemented before the completion of the software development
process and ensures the application can easily withstand high traffic without
any issues.
(8) Migration Testing:- Migration testing done to ensure that the software moved from old system infrastructures to current system infrastructures without any issues.
Advantages of System
Testing:-
i.
It covers end to
end testing.
ii. Proper Testing help in easing after production goes
live issues and bugs.
iii. System tests run naturally so that testing is done as
the application developer.
iv. Business requirements and software architecture are
tested.
v. The application tested thoroughly after each iteration
and run. Hence, there are lesser probabilities of failure and risks later on.
vi. System tests help to test that the application working
correctly from a user.
vii. System tests help specify how the application should
behave.
Disadvantages of
System Testing:-
i.
System Testing is
time consuming process than another testing techniques since it checks the
entire product or software.
ii. The cost for the testing will be high since it covers
the testing of entire software.
iii. It needs good debugging tool otherwise the hidden
errors will not be found.
iv. Can be time-consuming and expensive.
v. Requires adequate resources and infrastructure.
vi. Can be complex and challenging, especially for large
and complex systems.
vii. Dependent on the quality of requirements and design
documents.
viii.Requires specialized skills and expertise
Tools used for System
Testing:-
1. Selenium:- Used for
automated system testing of web applications. It supports multiple browsers
like Chrome, Firefox, and Edge.
2. TestComplete:- A commercial
automation tool used for system testing of desktop, web, and mobile
applications.
3. HP Unified Functional
Testing (UFT):- Used for automated functional and regression system testing.
4. IBM Rational Functional
Tester:- Used for automated system testing of web and desktop applications.
5. Katalon Studio:- Used for
system testing of web, API, desktop, and mobile applications.
6. Cucumber:- Used for
behavior-driven development (BDD) and system-level functional testing.
7. Appium:- Used for system
testing of Android and iOS mobile applications.
8. SoapUI:- Used for system testing of web
services and APIs.
9. LoadRunner:- Used for
performance and load testing at the system level.
10. JMeter:- Used for system
performance and load testing.
(4) ACCEPTANCE TESTING:- Acceptance testing is a crucial step in the software
development process, where the system is tested to ensure it meets requirements
and is ready for deployment. Acceptance testing involves end users or clients
testing the software in a real-world environment to validate its functionality,
usability, and reliability. This phase serves as the final verification step
before the software is released to production, preventing critical issues from
arising.
Purpose of Acceptance
Testing:-
i.
Validates user
and business needs to ensure satisfaction.
ii. Reduces post-launch risks by catching issues before
release.
iii. Acts as a final verification before deployment.
iv. Identifies requirement gaps between developers and users.
Types of acceptance
testing:-
(1) User Acceptance Tests (UAT) :- User acceptance testing is conducted by the end
users to verify that the software meets their needs and requirements. This type
of testing focuses on the functionality and usability of the software in
real-world scenarios.
(2) Business Acceptance Testing (BAT):- BAT is a part of a software program that focuses on
validating whether a software program meets the specified business necessities
and is ready for deployment or not. It is done in the final phase within the
testing methods, earlier than the software program is released to the customers
or clients. BAT guarantees that the software aligns with the enterprise's
desires, approaches, and expectancies, supplying self-assurance to stakeholders
that the system is suited for its intended purpose.
(3) Contract Acceptance Testing (CAT):- This is the last checkpoint that software solutions
must be thoroughly tested against requirements set by the customer’s
requirements stated in a contractual agreement. CAT works as an intermediary in
that the delivered software fits the requirements set. During this complex
procedure, careful checking of software’s functions, performance, reliability,
and contractual responsibilities is essential. The company will determine using
their structured and systematic way all that is needed so that the programmer
can understand well all that is entailed when he or she develops this software
program.
(4) Regulations Acceptance Testing (RAT):- RAT is termed a very crucial phase in the software
testing process. This type of testing is especially important in highly
regulated sectors such as healthcare, finance, and aerospace. RAT makes sure
that a product follows the rules and regulations, which are set up by the
government of the country where it's released.
(5) Operational Acceptance Testing (OAT):- Operational Acceptance Testing mainly focuses on the
operational readiness of the software and to become part of the production
environment. Operational Acceptance Testing is also known as Operational
Readiness Testing (ORT) or Operations Readiness and Assurance Testing (ORAT).
(6) Alpha Testing:- It aims to identify and fix bugs in a controlled
environment that simulates real-world conditions. This helps ensure the
software's functionality , reliability , and stability . Alpha testing combines
white-box and black-box testing techniques to explore and evaluate the
software.
(7) Beta Testing:- Beta testing is the process of testing a software
product or service in a real-world environment before its official release. It
is an essential step in the software development lifecycle as it helps identify
bugs and errors that may have been missed during the development process. During
beta testing, the software is made available to a selected group of users who
are willing to test the product and provide feedback to the developers.
Names of Acceptance
Testing Tools:-
1. Selenium:- A company tests
its online shopping website. Selenium automatically checks whether the login,
add-to-cart, and payment features work correctly before final approval by
users.
2. Cucumber:- In a banking
project, requirements are written in simple English like: “Given the user
enters correct ATM PIN, When they request balance, Then the system shows
account balance.” Cucumber converts these statements into automated acceptance
tests.
3. TestComplete:- A hospital
management system is tested to ensure patient registration and billing modules
work correctly before delivery to hospital staff.
4. FitNesse:- A team writes
acceptance test cases in a wiki format for a payroll system to verify salary
calculations before client approval.
5. Robot Framework:- A school
management software is tested to confirm student attendance and report
generation features work properly for final acceptance.
7. Jira + Zephyr:- A mobile
app, users report bugs in Jira, and test cases are managed using Zephyr before
final approval.
Advantages of
Acceptance Testing:-
i.
It helps to get
an idea about the future requirements from the clients while they share their
feedback on how the software is behaving.
ii. It allows automation of the acceptance test cases.
iii. It brings faith, trust and confidence of the clients
since they get the chance to actually use the software.
iv. It is a black box testing technique and hence
completely focussed on how the software is behaving.
Disadvantages of
Acceptance Testing:-
i.
The testers
verifying the software should have good knowledge on it.
ii. Occasionally, the customers may not like being dragged
to testing the software.
iii. It is a time consuming process to get all the feedback
from the customers. Moreover, they keep on changing from one person to another.
(2) NON-FUNCTIONAL
TESTING:-
Non-functional testing plays an
important role in the software testing process, focusing on the attributes of a
software application that determine its readiness and suitability. It examines
the system’s quality attributes, including performance, security, usability,
and reliability.
It directly impacts the user’s
experience and satisfaction with the software. For instance, how quickly does
the application load? Can it handle many users simultaneously without crashing?
Is it easy to use? How secure is it against cyber threats?
Non-functional testing is done
from a totally different perspective than functional testing. These types of
software testing services are a means of quality control, which is performed in
software applications to ensure that everything works well and to know in what
circumstances they might fail.
Objectives of
non-functional testing:- Its main
objective is the verification of a requirement that specifies criteria that can
be used to judge the operation of a system (non-functional requirements) such
as availability, accessibility, usability, maintainability, security,
performance. Other objectives are:
·
Verify quality
attributes which judge the operation of a system.
·
Determine system
compliance under certain conditions of use.
·
Detect problems
of product behavior by simulating real operating conditions.
Types of Non
Functional Testing:-
(1) Performance Testing:- Performance testing assesses the application’s
performance under specific conditions. It focuses on various aspects such as
response time, load time, and throughput rates under varying levels of user
traffic.
(2) Load Testing:- It is a subset of performance testing that examines
how the application behaves under an expected load of users or transactions.
The process identifies performance bottlenecks before the software goes live.
(3) Stress Testing:- Stress testing pushes the software beyond its normal
operational capacity, often to a breaking point, to see how it handles extreme
conditions. This helps identify the application’s upper limits and how it fails
under stress.
(4) Security Testing:- Security testing is critical in identifying
vulnerabilities (weakness), threats, and risks that could potentially lead to
data loss, breaches, or other security incidents. It ensures that the software
can protect data and maintain functionality as intended.
(5) Usability Testing:- This focuses on the user’s ease of using the
application, navigability, and overall user experience. Usability testing aims
to ensure that the software is intuitive and user-friendly.
(6) Compatibility Testing:- Compatibility testing checks the software’s
performance across browsers, operating systems, network environments, and mobile
devices to ensure consistent behavior and functionality.
(7) Scalability Testing:- Evaluate the software’s ability to scale up or down
in response to the application’s demands. Ensures the application can handle
growth in data, processing capacity, or number of users.
(8) Reliability Testing:- It verifies that the software can perform a specified
task under certain conditions for a defined period without failure. It assesses
the software’s reliability and fault tolerance.
NAME OF
NON-FUNCTIONAL TESTING TOOLS:-
1. Apache JMeter:- Load and
performance testing
2. LoadRunner:- Performance and
stress testing
3. NeoLoad:- Load and
scalability testing
4. Gatling:- High-performance
load testing
5. WebLOAD:-Web application
load testing
6. Burp Suite:- Security
testing
7. Acunetix:- Security testing
8. Appium:-Compatibility and
usability testing for mobile apps
9. GTmetrix:-Website speed
testing
Advantages of
Non-Functional Testing:-
·
Enhanced
Security:- Ensures systems are protected against online threats, safeguarding
data and user trust.
·
Improved Load
Handling:- Guarantees the system’s ability to handle concurrent users without
performance issues.
·
Increased
Efficiency:- Optimizes the system to perform tasks quickly and effectively
under various conditions.
·
Reusable Test
Cases:- Test cases remain unchanged, eliminating the need to rewrite them
repeatedly.
·
Reduced Time
Commitment:- Requires less time compared to other testing procedures,
streamlining the testing process.
Disadvantages of
Non-functional Testing
·
Non-functional
tests are performed repeatedly:- Whenever there is a change in the application,
non-functional testing is performed again. Thus, it is more resource intensive.
·
Expensive in case
of software update:- In case of software update, non-functional testing is
performed again thus incurring extra charges to re-examine the software, and
thus software becomes expensive.
TESTING LIFE CYCLE
AND TESTING METHODOLOGIES:-
SOFTWARE TESTING LIFE
CYCLE :- Software Testing Life Cycle
(STLC) is a fundamental part of the Software Development Life Cycle (SDLC).
Software testing life cycle
(STLC) is a sequence of verification and validation activities carried out in
the course of software development to ensure that the software under test is
functioning properly. It aligns with the requirements set out before the
development team. During the lifecycle. The Software Testing Life Cycle (STLC)
is a process that verifies whether the Software Quality meets the expectations
or not. STLC is an important process that provides a simple approach to testing
through the step-by-step process.
Phases of Software
Testing Life Cycle (STLC) / Testing Methodologies are:-
The different phases of
Software testing life cycle are:
(1) Requirement Analysis:- Requirement Analysis is the first step involved in
Software testing life cycle. In this step, Quality Assurance (QA) team
understands the requirement in terms of what we will testing & figure out
the testable requirements. During this phase, test team studies the
requirements from a testing point of view to identify the testable
requirements. The QA team may interact with various stakeholders such as
client, business analyst, technical leads, system architects etc. to understand
the requirements in detail.
(2) Test Planning:- Test
Planning is the most important phase of Software testing life cycle where all
testing strategy is defined. This phase is also called as Test Strategy phase.
In this phase, the Test Manager is involved to determine the effort and cost
estimates for the entire project. It defines the objective & scope of the
project.
The commonly used Testing types
are :- Unit Test, API Testing, Integration Test, System Test, Install/Uninstall
Testing, Agile Testing
(3) Test Case Development:- The Test case development begins once the test
planning phase is completed. This is the phase of STLC where testing team notes
the detailed test cases. Along with test cases, testing team also prepares the
test data for testing.
A good test case is the one
which is effective at finding defects and also covers most of the scenarios on
the system under test. Here is the step by step guide on how to develop a good
test case :-
·
Test cases need
to be simple and transparent
·
Create test case with
end user in mind
·
Avoid test case
repetition
·
Do not assume
functionality and features of your software application
·
Ensure 100%
coverage of software requirements
·
Name the test
case id such that they are identified easily while tracking defects
·
Implement testing
techniques
·
The test case you
create must return the Test Environment to the pre-test state
·
The test case
should generate the same results every time
·
Your peers should
be able to uncover defects in your test case design
(4) Environment Setup:- Setting up the test environment is vital part of the
Software Testing Life Cycle. A testing environment is a setup of software and
hardware for the testing teams to execute test cases. It supports test
execution with hardware, software and network configured.
The test environment involves
setting up of distinct areas like :
·
Setup of Test
Server – Every test may not be executed on a local machine. It may need
establishing a test server, which can support applications.
·
Network – We need
to set up the network as per requirements.
·
Test PC Setup –
We need to set up different browsers for different testers.
·
Bug Reporting –
Bug reporting tools should be provided to testers.
·
Creating Test
Data for the Test Environment – Many companies use a separate test environment
to test the software product. The common approach used is to copy production
data to test.
(5) Test Execution: Test execution is the process of executing the code
and comparing the expected and actual results. When test execution begins, the
test analysts start executing the test scripts based on test strategy allowed
in the project.
Activities of Test Execution:-
·
Mark status of
test cases like Passed, Failed, Blocked, Not Run etc.
·
Assign Bug Id for
all failed and blocked test cases.
·
Do Retesting once
the defects are fixed.
·
Track the defects
to closure.
(6) Test Cycle Closure:- It involves calling out the testing team member
meeting & evaluating cycle completion criteria based on Test coverage,
Quality, Cost, Time, Critical Business Objectives, and Software.
A test closure report by the
test lead is published after accomplishing the exit criteria and finishing the
testing phase. It follows a standard format such as :-
·
Test Summary
Report
·
Identifier
·
Test Summary
·
Variances
·
Comprehensiveness
Assessment
·
Summary of
Results
·
Evaluation
·
Summary of
Activities
·
Approval
Advantages of STLC:-
(1) Adopting shift-left testing:- This allows teams to start
testing earlier in the development cycle, enabling them to proactively identify
and resolve potential issues.
(2) Improved tracking:- By implementing a structured framework
with clear goals and phases, Quality Assurance teams can better monitor their
progress and effectively address any discrepancies that may arise.
(3) Faster bug detection:- Testing at earlier stages of software
development helps identify and fix bugs more quickly, leading to faster
resolution and smoother project progress.
DIFFERENCE BETWEEN
SDLC AND STLC
|
Parameter |
SDLC |
STLC |
|
Origin |
Software
Development Life Cycle |
Software Testing
Life Cycle |
|
Definition |
SDLC focuses on
delivering a high-quality system that meets or exceeds user expectations,
operates effectively within current and planned IT infrastructure, and is
cost-efficient to maintain. |
STLC defines the
sequence of testing activities, specifying what tests to perform and when, to
ensure thorough validation. While testing processes vary by organization, a
structured test life cycle exists. |
|
Focus |
Covers both
development and testing processes |
Focuses solely
on the testing process |
|
Performed |
SDLC phases
complete before the start of STLC phases |
STLC phases are
executed after the SDLC phases |
|
Objective |
To successfully
overcome challenges in software development and deliver a functional product |
To identify
defects or weaknesses in the software |
|
Relationship
with Other Life Cycle |
Precedes STLC |
Follows SDLC |
|
Team
Involved |
Project
Managers, Business Analysts, Designers, Developers |
Quality
Assurance and Testing Teams |
|
Prime
goal |
Deliver a
reliable, fully functional software product |
Verify that the
software meets requirements and functions correctly |
|
Distinct
phases |
Requirements
gathering, design, development, testing, deployment, and maintenance |
Test planning,
test design, test execution, defect tracking, and test closure |
|
Coverage |
Encompasses the
entire software development lifecycle, from initiation to deployment |
Encompasses the
complete testing process, from planning through closure |
|
Core
Relationship |
SDLC is followed
by STLC to validate and verify the software product |
STLC is an
integral part of SDLC, ensuring thorough testing before deployment |
|
Outcome |
Delivery of a
high-quality software product that meets business needs |
Delivery of
software with minimized bugs and verified quality |
UNIT 1 THE END (INTRODUCTION TO SOFTWARE TESTING)
No comments:
Post a Comment
PLEASE DO LEAVE YOUR COMMENTS